home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / gdb-4.5 / dist / gdb / arm-pinsn.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-03  |  6.7 KB  |  270 lines
  1. /* Print Acorn Risc Machine instructions for GDB, the GNU debugger.
  2.    Copyright 1986, 1989, 1991 Free Software Foundation, Inc.
  3.  
  4. This file is part of GDB.
  5.  
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2 of the License, or
  9. (at your option) any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. #include "defs.h"
  21. #include <ctype.h>
  22. #include <assert.h>
  23.  
  24. #include "symtab.h"
  25. #include "opcode/arm.h"
  26.  
  27. extern char *reg_names[];
  28.  
  29. static char *shift_names[] = {
  30.     "lsl", "lsr", "asr", "ror",
  31. };
  32.  
  33. static char *cond_names[] = {
  34.     "eq", "ne", "cs", "cc", "mi", "pl", "vs", "vc",
  35.     "hi", "ls", "ge", "lt", "gt", "le", "", "nv"
  36. };
  37.  
  38. static char float_precision[] = "sdep";
  39. static char float_rounding[] = " pmz";
  40. static float float_immed[] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 0.5, 10.0 };
  41.  
  42. static void print_ldr_str_offset();
  43. static void print_ldc_stc_offset();
  44. static long immediate_value();
  45.  
  46. /* Print the ARM instruction at address MEMADDR in debugged memory,
  47.    on STREAM.  Returns length of the instruction, in bytes.  */
  48.  
  49. int
  50. print_insn (memaddr, stream)
  51.      CORE_ADDR memaddr;
  52.      FILE *stream;
  53. {
  54.     unsigned long ins;
  55.     register struct opcode *op;
  56.     register char *p;
  57.     register int i, c;
  58.     int s, e, val;
  59.  
  60.     ins = read_memory_integer(memaddr, 4);
  61.     for (i = 0, op = opcodes; i < N_OPCODES; i++, op++)
  62.     if ((ins & op->mask) == op->value) break;
  63.     assert(i != N_OPCODES);
  64.     
  65.     for (p = op->assembler; *p;) {
  66.     c = *p++;
  67.     if (c == '%') {
  68.         s = e = 0;
  69.         while (isdigit(*p))
  70.         s = s*10 + (*p++ - '0');
  71.         if (*p == '-') {
  72.         p++;
  73.         while (isdigit(*p))
  74.             e = e*10 + (*p++ - '0');
  75.         } else
  76.         e = s;
  77.         assert(s >= 0 && s <= 31 && e >= 0 && e <= 31);
  78.         val = (ins >> s) & ((1 << (e + 1 - s)) - 1);
  79.         switch (*p++) {
  80.         case '%' :
  81.         putc('%', stream);
  82.         break;
  83.         case 'd' :
  84.         fprintf(stream, "%d", val);
  85.         break;
  86.         case 'x' :
  87.         fprintf(stream, "%x", val);
  88.         break;
  89.         case 'r' :
  90.         assert(val >= 0 && val <= 15);
  91.         fprintf(stream, "%s", reg_names[val]);
  92.         break;
  93.         case 'c' :
  94.         fprintf(stream, "%s", cond_names[ins >> 28]);
  95.         break;
  96.         case '\'' :
  97.         assert(*p);
  98.         c = *p++;
  99.         if (val)
  100.             putc(c, stream);
  101.         break;
  102.         case '`' :
  103.         assert(*p);
  104.         c = *p++;
  105.         if (!val)
  106.             putc(c, stream);
  107.         break;
  108.         case '?' :
  109.         assert(*p);
  110.         c = *p++;
  111.         assert(*p);
  112.         if (val)
  113.             p++;
  114.         else
  115.             c = *p++;
  116.         putc(c, stream);
  117.         break;
  118.         case 'p' :
  119.         if (((ins >> 12) & 0xf) == 0xf)
  120.             putc('p', stream);
  121.         break;
  122.         case 'o' :
  123.         if (ins & (1<<25)) {
  124.             int immed = immediate_value(ins & 0xfff);
  125.             fprintf (stream, "#%d (0x%x)", immed, immed);
  126.         } else {
  127.             int operand2 = ins & 0xfff;
  128.             /* in operand2 :
  129.                bits 0-3 are the base register
  130.                bits 5-6 are the shift (0=lsl, 1=lsr, 2=asr, 3=ror)
  131.                if bit 4 is zero then bits 7-11 are an immediate shift count
  132.                else bit 7 must be zero and bits 8-11 are the register
  133.                to be used as a shift count.
  134.                Note: no shift at all is encoded as "reg lsl #0" */
  135.             fprintf (stream, "%s", reg_names[operand2 & 0xf]);
  136.             if (operand2 & 0xff0) {
  137.             /* ror #0 is really rrx (rotate right extend) */
  138.             if ((operand2 & 0xff0) == 0x060)
  139.                 fprintf (stream, ", rrx");
  140.             else {
  141.                 fprintf (stream, ", %s ",
  142.                      shift_names[(operand2 >> 5) & 3]);
  143.                 if (operand2 & (1<<4)) /* register shift */
  144.                 fprintf (stream, "%s",
  145.                      reg_names[operand2 >> 8]);
  146.                 else    /* immediate shift */
  147.                 fprintf (stream, "#%d",
  148.                      operand2 >> 7);
  149.             }
  150.             }
  151.         }
  152.         break;
  153.         case 'a' :
  154.         fprintf (stream, "[%s", reg_names[(ins >> 16) & 0xf]);
  155.         if (ins & (1<<24)) {
  156.             fprintf (stream, ", ");
  157.             print_ldr_str_offset (ins, stream);
  158.             putc (']', stream);
  159.             if (ins & (1<<21)) putc('!', stream);
  160.             /* If it is a pc relative load, then it is probably
  161.                a constant so print it */
  162.             if (((ins >> 16) & 0xf) == 15 &&
  163.             (ins & (1<<25)) == 0 &&
  164.             (ins & (1<<20))) {
  165.             int addr = memaddr + 8 +
  166.                 (ins & 0xfff) * ((ins & (1<<23)) ? 1 : -1);
  167.             fprintf (stream, " (contents=");
  168.             print_address (read_memory_integer(addr, 4), stream);
  169.             fprintf (stream, ")");
  170.             }
  171.         } else {
  172.             fprintf (stream, "]," );
  173.             print_ldr_str_offset (ins, stream);
  174.         }
  175.         break;
  176.         case 'b' :
  177.         print_address (memaddr + 8 + (((int)ins << 8) >> 6), stream);
  178.         break;
  179.         case 'A' :
  180.         fprintf (stream, "[%s", reg_names[(ins >> 16) & 0xf]);
  181.         if (ins & (1<<24)) {
  182.             fprintf (stream, ", ");
  183.             print_ldc_stc_offset (ins, stream);
  184.             putc(']', stream);
  185.             if (ins & (1<<21))
  186.             putc('!', stream);
  187.         } else {
  188.             fprintf (stream, "], ");
  189.             print_ldc_stc_offset (ins, stream);
  190.         }
  191.         break;
  192.         case 'm' :
  193.         {
  194.             int regnum, first = 1;
  195.             putc('{', stream);
  196.             for (regnum = 0; regnum < 16; regnum++)
  197.             if (ins & (1<<regnum)) {
  198.                 if (!first)
  199.                 putc (',', stream);
  200.                 first = 0;
  201.                 fprintf (stream, "%s", reg_names[regnum]);
  202.             }
  203.             putc('}', stream);
  204.         }
  205.         break;
  206.         case 'P' :
  207.         val = ((ins >> 18) & 2) | ((ins >> 7) & 1);
  208.         putc(float_precision[val], stream);
  209.         break;
  210.         case 'Q' :
  211.         val = ((ins >> 21) & 2) | ((ins >> 15) & 1);
  212.         putc(float_precision[val], stream);
  213.         break;
  214.         case 'R' :
  215.         val = ((ins >> 5) & 3);
  216.         if (val) putc(float_rounding[val], stream);
  217.         break;
  218.         case 'f' :
  219.         assert(val >= 0 && val <= 15);
  220.         if (val > 7)
  221.             fprintf (stream, "#%3.1f", float_immed[val - 8]);
  222.         else
  223.             fprintf (stream, "f%d", val);
  224.         break;
  225.         default:
  226.         abort();
  227.         }
  228.     } else
  229.         putc(c, stream);
  230.     }
  231.     return 4;
  232. }
  233.  
  234. static long
  235. immediate_value(operand)
  236. int operand;
  237. {
  238.     int val = operand & 0xff;
  239.     int shift = 2*(operand >> 8);
  240.     /* immediate value is (val ror shift) */
  241.     return (val >> shift) | (val << (32 - shift));
  242. }
  243.  
  244. static void
  245. print_ldr_str_offset(ins, stream)
  246. unsigned long ins;
  247. FILE *stream;
  248. {
  249.     if ((ins & (1<<25)) == 0)
  250.     fprintf (stream, "#%d",
  251.          (ins & 0xfff) * ((ins & (1<<23)) ? 1 : -1));
  252.     else {
  253.     fprintf (stream, "%s%s", reg_names[ins & 0xf],
  254.          (ins & (1<<23)) ? "" : "-");
  255.     if (ins & 0xff0)
  256.         fprintf (stream, ", %s #%d",
  257.              shift_names[(ins >> 5) & 3],
  258.              (ins >> 7) & 0x1f);
  259.     }
  260. }
  261.  
  262. static void
  263. print_ldc_stc_offset(ins, stream)
  264. unsigned long ins;
  265. FILE *stream;
  266. {
  267.     fprintf (stream, "#%d",
  268.          4 * (ins & 0xff) * ((ins & (1<<23)) ? 1 : -1));
  269. }
  270.